// 企业级网络请求封装
import axios from 'axios'
import { ElMessage } from 'element-plus'

// 浏览器存储工具函数
const getStorage = (key) => {
  try {
    const value = localStorage.getItem(key)
    if (!value) return null

    // 尝试解析JSON，如果失败则返回原始值（适用于token等字符串）
    try {
      return JSON.parse(value)
    } catch {
      return value
    }
  } catch (error) {
    console.error('获取存储失败:', error)
    return null
  }
}

const removeStorage = (key) => {
  try {
    localStorage.removeItem(key)
  } catch (error) {
    console.error('移除存储失败:', error)
  }
}

// Toast提示函数 - 使用Element Plus
const showToast = (message, type = 'error') => {
  ElMessage({
    message,
    type: type === 'error' ? 'error' : 'success',
    duration: 2000,
    showClose: true,
  })
}

// 判断当前平台 - Vue3项目统一为web平台
const isH5 = true

// 基础配置
const BASE_CONFIG = {
  // 开发环境使用代理，生产环境使用环境变量或默认地址
  baseURL: import.meta.env.DEV
    ? '/api/v2/open/worksheet'
    : import.meta.env.VITE_API_BASE ,
  timeout: 10000,
  retryCount: 7,
  retryDelay: 800,
}

// 创建axios实例
const axiosInstance = axios.create({
  baseURL: BASE_CONFIG.baseURL,
  timeout: BASE_CONFIG.timeout,
  headers: {
    'Content-Type': 'application/json',
  },
})

// 请求缓存
const requestCache = new Map()
// 正在进行的请求
const pendingRequests = new Map()
// 请求队列控制
let activeRequests = 0
const MAX_CONCURRENT_REQUESTS = 6

// 生成请求缓存key
const generateCacheKey = (options) => {
  const { url, method = 'GET', data } = options
  return `${method}:${url}:${JSON.stringify(data || {})}`
}

// 延迟函数
const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

// 请求拦截器
axiosInstance.interceptors.request.use(
  (config) => {
    // 添加token
    const token = getStorage('token')
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`
    }
    return config
  },
  (error) => {
    return Promise.reject(error)
  },
)

// 响应拦截器
axiosInstance.interceptors.response.use(
  (response) => {
    const { status, data } = response

    // 调试信息（生产环境可以关闭）
    if (import.meta.env.DEV) {
      console.log('【responseInterceptor】status:', status, 'data:', data)
    }

    // 业务逻辑处理 - 只在响应层面处理，不显示错误提示
    if (!data.success) {
      // 如果是worksheetId不存在的错误，创建特殊的错误对象
      if (data.error_msg === 'worksheetId不存在') {
        const error = new Error(data.error_msg)
        error.isWorksheetNotExist = true
        throw error
      }
      // 不再这里显示错误提示，交由重试逻辑处理
      throw new Error(data.error_msg || data.message || '请求失败')
    }

    return data.data
  },
  (error) => {
    const { response } = error

    // 统一错误处理
    if (response?.status === 401) {
      // token过期处理
      removeStorage('token')
      // 跳转到登录页面
      if (window.location.pathname !== '/login') {
        window.location.href = '/login'
      }
      showToast('登录已过期')
      return Promise.reject(new Error('登录已过期'))
    }

    if (response?.status >= 400) {
      // 不再这里显示错误提示，交由重试逻辑处理
      return Promise.reject(new Error(`请求错误: ${response.status}`))
    }

    // 网络错误 - 不再这里显示错误提示，交由重试逻辑处理
    return Promise.reject(error)
  },
)

// 带重试的请求函数
const requestWithRetry = async (options, retryCount = 0) => {
  try {
    // 控制并发请求数量
    while (activeRequests >= MAX_CONCURRENT_REQUESTS) {
      await delay(100)
    }

    activeRequests++

    const result = await axiosInstance.request(options)
    activeRequests--
    return result
  } catch (error) {
    activeRequests--

    // 重试逻辑 - 如果是worksheetId不存在的错误，不重试
    if (error.isWorksheetNotExist) {
      throw error
    }

    if (retryCount < BASE_CONFIG.retryCount) {
      console.log(`请求失败，第${retryCount + 1}次重试...`)
      await delay(BASE_CONFIG.retryDelay)
      return requestWithRetry(options, retryCount + 1)
    }

    // 只有在达到最大重试次数时才显示错误提示
    if (retryCount >= BASE_CONFIG.retryCount) {
      // 获取错误信息
      let errorMessage = '网络连接失败，请检查网络'

      if (error.response?.data?.message) {
        errorMessage = error.response.data.message
      } else if (error.response?.data?.error_msg) {
        errorMessage = error.response.data.error_msg
      } else if (error.response?.status) {
        errorMessage = `请求错误: ${error.response.status}`
      } else if (error.message) {
        errorMessage = error.message
      }

      showToast(errorMessage)
    }

    throw error
  }
}

// 核心请求函数
const request = (options) => {
  const cacheKey = generateCacheKey(options)

  // 检查是否有相同请求正在进行
  if (pendingRequests.has(cacheKey)) {
    return pendingRequests.get(cacheKey)
  }

  // 检查缓存（只缓存GET请求，且缓存时间不超过30秒）
  if (options.method === 'GET' || !options.method) {
    const cached = requestCache.get(cacheKey)
    if (cached && Date.now() - cached.timestamp < 30000) {
      console.log('使用缓存数据:', cacheKey)
      return Promise.resolve(cached.data)
    }
  }

  // 创建请求Promise
  const requestPromise = requestWithRetry(options)
    .then((result) => {
      // 缓存GET请求结果
      if (options.method === 'GET' || !options.method) {
        requestCache.set(cacheKey, {
          data: result,
          timestamp: Date.now(),
        })

        // 限制缓存数量，防止内存泄漏
        if (requestCache.size > 50) {
          const firstKey = requestCache.keys().next().value
          requestCache.delete(firstKey)
        }
      }

      return result
    })
    .finally(() => {
      // 请求完成后从pending中移除
      pendingRequests.delete(cacheKey)
    })

  // 将请求添加到pending中
  pendingRequests.set(cacheKey, requestPromise)

  return requestPromise
}

// 清除缓存的方法
const clearCache = (pattern) => {
  if (pattern) {
    // 清除匹配模式的缓存
    for (const key of requestCache.keys()) {
      if (key.includes(pattern)) {
        requestCache.delete(key)
      }
    }
  } else {
    // 清除所有缓存
    requestCache.clear()
  }
}

// 快捷方法
const http = {
  get: (url, params = {}, options = {}) => {
    return request({
      url,
      method: 'GET',
      params,
      ...options,
    })
  },

  post: (url, data = {}, options = {}) => {
    return request({
      url,
      method: 'POST',
      data,
      ...options,
    })
  },

  put: (url, data = {}, options = {}) => {
    return request({
      url,
      method: 'PUT',
      data,
      ...options,
    })
  },

  delete: (url, data = {}, options = {}) => {
    return request({
      url,
      method: 'DELETE',
      data,
      ...options,
    })
  },

  upload: (url, file, formData = {}) => {
    return new Promise((resolve, reject) => {
      const data = new FormData()
      data.append('file', file)

      // 添加其他表单数据
      Object.keys(formData).forEach((key) => {
        data.append(key, formData[key])
      })

      axiosInstance
        .post(url, data, {
          headers: {
            'Content-Type': 'multipart/form-data',
            Authorization: `Bearer ${getStorage('token')}`,
          },
        })
        .then((response) => {
          resolve(response)
        })
        .catch((error) => {
          showToast('上传失败')
          reject(error)
        })
    })
  },

  // 新增方法：清除缓存
  clearCache,

  // 新增方法：预加载请求
  preload: (url, params = {}, method = 'GET') => {
    const requestMethod = method.toLowerCase()
    if (requestMethod === 'post') {
      return http.post(url, params).catch(() => {
        // 预加载失败不处理，避免影响用户体验
      })
    } else {
      return http.get(url, params).catch(() => {
        // 预加载失败不处理，避免影响用户体验
      })
    }
  },
}

export default http
export { getStorage, removeStorage, showToast }
